home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / mozilla-firefox / include / websrvcs / nsIWebServiceProxy.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-05-08  |  35.2 KB  |  911 lines
  1. /*
  2.  * DO NOT EDIT.  THIS FILE IS GENERATED FROM nsIWebServiceProxy.idl
  3.  */
  4.  
  5. #ifndef __gen_nsIWebServiceProxy_h__
  6. #define __gen_nsIWebServiceProxy_h__
  7.  
  8.  
  9. #ifndef __gen_nsISupports_h__
  10. #include "nsISupports.h"
  11. #endif
  12.  
  13. #ifndef __gen_nsIWSDL_h__
  14. #include "nsIWSDL.h"
  15. #endif
  16.  
  17. #ifndef __gen_nsISimpleEnumerator_h__
  18. #include "nsISimpleEnumerator.h"
  19. #endif
  20.  
  21. #ifndef __gen_nsIException_h__
  22. #include "nsIException.h"
  23. #endif
  24.  
  25. #ifndef __gen_nsISOAPResponse_h__
  26. #include "nsISOAPResponse.h"
  27. #endif
  28.  
  29. #ifndef __gen_nsISOAPBlock_h__
  30. #include "nsISOAPBlock.h"
  31. #endif
  32.  
  33. #ifndef __gen_nsIScriptableInterfaces_h__
  34. #include "nsIScriptableInterfaces.h"
  35. #endif
  36.  
  37. /* For IDL files that don't want to include root IDL files. */
  38. #ifndef NS_NO_VTABLE
  39. #define NS_NO_VTABLE
  40. #endif
  41. class nsIWebServiceProxy; /* forward declaration */
  42.  
  43. class nsIWebServiceProxyCreationListener; /* forward declaration */
  44.  
  45. class nsIInterfaceInfo; /* forward declaration */
  46.  
  47. class nsIPropertyBag; /* forward declaration */
  48.  
  49.  
  50. /* starting interface:    nsIWebServiceProxyFactory */
  51. #define NS_IWEBSERVICEPROXYFACTORY_IID_STR "693611be-bb38-40e0-a98e-b46ff8a5bcca"
  52.  
  53. #define NS_IWEBSERVICEPROXYFACTORY_IID \
  54.   {0x693611be, 0xbb38, 0x40e0, \
  55.     { 0xa9, 0x8e, 0xb4, 0x6f, 0xf8, 0xa5, 0xbc, 0xca }}
  56.  
  57. class NS_NO_VTABLE nsIWebServiceProxyFactory : public nsISupports {
  58.  public: 
  59.  
  60.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IWEBSERVICEPROXYFACTORY_IID)
  61.  
  62.   /**
  63.    * Create a service proxy. Loading of the WSDL URL will occur
  64.    * in a synchronous manner. Calls to web service can be made as
  65.    * soon as this method completes.
  66.    *
  67.    * @param wsdlURL The URL of the WSDL service description. This
  68.    *                description will be loaded and used as the basis
  69.    *                for the service proxy.
  70.    * @param portname The name of the port of the service that this 
  71.    *                 service proxy represents. Currently the port
  72.    *                 must represent a SOAP binding.
  73.    * @param qualifier The user-specified qualifier is incorporated into
  74.    *                  the names of XPCOM interfaces created for the 
  75.    *                  service proxy. For C++ callers, this qualifier 
  76.    *                  should be the  same one used in creating the IDL 
  77.    *                  used at compile time. Script callers need not 
  78.    *                  specify a qualifier.
  79.    * @param isAsync If PR_TRUE, the method signatures of the service
  80.    *                proxy represent an asynchronous calling convention.
  81.    *                A callback instance must be registered with the proxy.
  82.    *                A method call to a web service is only completed when
  83.    *                the corresponding callback method is invoked.
  84.    *                If PR_FALSE, the method signatures of the service
  85.    *                proxy represent a synchronous callling convention.
  86.    *                A method call to a web service is completed when the
  87.    *                method call to the proxy returns.
  88.    */
  89.   /* nsIWebServiceProxy createProxy (in AString wsdlURL, in AString portname, in AString qualifier, in boolean isAsync); */
  90.   NS_IMETHOD CreateProxy(const nsAString & wsdlURL, const nsAString & portname, const nsAString & qualifier, PRBool isAsync, nsIWebServiceProxy **_retval) = 0;
  91.  
  92.   /**
  93.    * Create a service proxy. Loading of the WSDL URL will occur
  94.    * in an asynchronous manner. Methods on the listener instance will
  95.    * be invoked when the proxy has been created. Any method invocations
  96.    * on the service proxy prior to asynchronous completion of the 
  97.    * intialization step will fail. The caller is guaranteed that this
  98.    * method will return before the listener is invoked.
  99.    *
  100.    * @param wsdlURL The URL of the WSDL service description. This
  101.    *                description will be loaded and used as the basis
  102.    *                for the service proxy.
  103.    * @param portname The name of the port of the service that this 
  104.    *                 service proxy represents. Currently the port
  105.    *                 must represent a SOAP binding.
  106.    * @param qualifier The user-specified qualifier is incorporated into
  107.    *                  the names of XPCOM interfaces created for the 
  108.    *                  service proxy. For C++ callers, this qualifier 
  109.    *                  should be the same one used in creating the IDL 
  110.    *                  used at compile time. Script callers need not 
  111.    *                  specify a qualifier.
  112.    * @param isAsync If PR_TRUE, the method signatures of the service
  113.    *                proxy represent an asynchronous calling convention.
  114.    *                A callback instance must be registered with the proxy.
  115.    *                A method call to a web service is only completed when
  116.    *                the corresponding callback method is invoked.
  117.    *                If PR_FALSE, the method signatures of the service
  118.    *                proxy represent a synchronous callling convention.
  119.    *                A method call to a web service is completed when the
  120.    *                method call to the proxy returns.
  121.    * @param listener The callback instance which will be invoked when
  122.    *                 the proxy is completely initialized.
  123.    */
  124.   /* void createProxyAsync (in AString wsdlURL, in AString portname, in AString qualifier, in boolean isAsync, in nsIWebServiceProxyCreationListener listener); */
  125.   NS_IMETHOD CreateProxyAsync(const nsAString & wsdlURL, const nsAString & portname, const nsAString & qualifier, PRBool isAsync, nsIWebServiceProxyCreationListener *listener) = 0;
  126.  
  127. };
  128.  
  129. /* Use this macro when declaring classes that implement this interface. */
  130. #define NS_DECL_NSIWEBSERVICEPROXYFACTORY \
  131.   NS_IMETHOD CreateProxy(const nsAString & wsdlURL, const nsAString & portname, const nsAString & qualifier, PRBool isAsync, nsIWebServiceProxy **_retval); \
  132.   NS_IMETHOD CreateProxyAsync(const nsAString & wsdlURL, const nsAString & portname, const nsAString & qualifier, PRBool isAsync, nsIWebServiceProxyCreationListener *listener); 
  133.  
  134. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  135. #define NS_FORWARD_NSIWEBSERVICEPROXYFACTORY(_to) \
  136.   NS_IMETHOD CreateProxy(const nsAString & wsdlURL, const nsAString & portname, const nsAString & qualifier, PRBool isAsync, nsIWebServiceProxy **_retval) { return _to CreateProxy(wsdlURL, portname, qualifier, isAsync, _retval); } \
  137.   NS_IMETHOD CreateProxyAsync(const nsAString & wsdlURL, const nsAString & portname, const nsAString & qualifier, PRBool isAsync, nsIWebServiceProxyCreationListener *listener) { return _to CreateProxyAsync(wsdlURL, portname, qualifier, isAsync, listener); } 
  138.  
  139. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  140. #define NS_FORWARD_SAFE_NSIWEBSERVICEPROXYFACTORY(_to) \
  141.   NS_IMETHOD CreateProxy(const nsAString & wsdlURL, const nsAString & portname, const nsAString & qualifier, PRBool isAsync, nsIWebServiceProxy **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->CreateProxy(wsdlURL, portname, qualifier, isAsync, _retval); } \
  142.   NS_IMETHOD CreateProxyAsync(const nsAString & wsdlURL, const nsAString & portname, const nsAString & qualifier, PRBool isAsync, nsIWebServiceProxyCreationListener *listener) { return !_to ? NS_ERROR_NULL_POINTER : _to->CreateProxyAsync(wsdlURL, portname, qualifier, isAsync, listener); } 
  143.  
  144. #if 0
  145. /* Use the code below as a template for the implementation class for this interface. */
  146.  
  147. /* Header file */
  148. class nsWebServiceProxyFactory : public nsIWebServiceProxyFactory
  149. {
  150. public:
  151.   NS_DECL_ISUPPORTS
  152.   NS_DECL_NSIWEBSERVICEPROXYFACTORY
  153.  
  154.   nsWebServiceProxyFactory();
  155.  
  156. private:
  157.   ~nsWebServiceProxyFactory();
  158.  
  159. protected:
  160.   /* additional members */
  161. };
  162.  
  163. /* Implementation file */
  164. NS_IMPL_ISUPPORTS1(nsWebServiceProxyFactory, nsIWebServiceProxyFactory)
  165.  
  166. nsWebServiceProxyFactory::nsWebServiceProxyFactory()
  167. {
  168.   /* member initializers and constructor code */
  169. }
  170.  
  171. nsWebServiceProxyFactory::~nsWebServiceProxyFactory()
  172. {
  173.   /* destructor code */
  174. }
  175.  
  176. /* nsIWebServiceProxy createProxy (in AString wsdlURL, in AString portname, in AString qualifier, in boolean isAsync); */
  177. NS_IMETHODIMP nsWebServiceProxyFactory::CreateProxy(const nsAString & wsdlURL, const nsAString & portname, const nsAString & qualifier, PRBool isAsync, nsIWebServiceProxy **_retval)
  178. {
  179.     return NS_ERROR_NOT_IMPLEMENTED;
  180. }
  181.  
  182. /* void createProxyAsync (in AString wsdlURL, in AString portname, in AString qualifier, in boolean isAsync, in nsIWebServiceProxyCreationListener listener); */
  183. NS_IMETHODIMP nsWebServiceProxyFactory::CreateProxyAsync(const nsAString & wsdlURL, const nsAString & portname, const nsAString & qualifier, PRBool isAsync, nsIWebServiceProxyCreationListener *listener)
  184. {
  185.     return NS_ERROR_NOT_IMPLEMENTED;
  186. }
  187.  
  188. /* End of implementation class template. */
  189. #endif
  190.  
  191.  
  192. /* starting interface:    nsIWebServiceProxyCreationListener */
  193. #define NS_IWEBSERVICEPROXYCREATIONLISTENER_IID_STR "a711250b-47da-4f16-a1fd-593de16375a1"
  194.  
  195. #define NS_IWEBSERVICEPROXYCREATIONLISTENER_IID \
  196.   {0xa711250b, 0x47da, 0x4f16, \
  197.     { 0xa1, 0xfd, 0x59, 0x3d, 0xe1, 0x63, 0x75, 0xa1 }}
  198.  
  199. class NS_NO_VTABLE nsIWebServiceProxyCreationListener : public nsISupports {
  200.  public: 
  201.  
  202.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IWEBSERVICEPROXYCREATIONLISTENER_IID)
  203.  
  204.   /**
  205.  * This interface should be implemented by a user who creates
  206.  * a web service proxy in an asynchronous manner. An instance
  207.  * of this interface is passed into the <code>initAsync</code>
  208.  * method of the proxy.
  209.  */
  210. /**
  211.    * Invoked when the proxy is completely initialized. Method
  212.    * calls on the proxy can be made once this method is called.
  213.    * 
  214.    * @param proxy The initialized web service proxy
  215.    */
  216.   /* void onLoad (in nsIWebServiceProxy proxy); */
  217.   NS_IMETHOD OnLoad(nsIWebServiceProxy *proxy) = 0;
  218.  
  219.   /**
  220.    * Invoked if an error occurs during web service proxy
  221.    * initialization. This error code be a result of attempting
  222.    * to load the specified WSDL URL or a result of processing
  223.    * the WSDL and creating the interface information for the 
  224.    * proxy.
  225.    *
  226.    * @param error The exception generated as a result of the
  227.    *                  error. This object can be introspected
  228.    *                  for further information.
  229.    */
  230.   /* void onError (in nsIException error); */
  231.   NS_IMETHOD OnError(nsIException *error) = 0;
  232.  
  233. };
  234.  
  235. /* Use this macro when declaring classes that implement this interface. */
  236. #define NS_DECL_NSIWEBSERVICEPROXYCREATIONLISTENER \
  237.   NS_IMETHOD OnLoad(nsIWebServiceProxy *proxy); \
  238.   NS_IMETHOD OnError(nsIException *error); 
  239.  
  240. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  241. #define NS_FORWARD_NSIWEBSERVICEPROXYCREATIONLISTENER(_to) \
  242.   NS_IMETHOD OnLoad(nsIWebServiceProxy *proxy) { return _to OnLoad(proxy); } \
  243.   NS_IMETHOD OnError(nsIException *error) { return _to OnError(error); } 
  244.  
  245. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  246. #define NS_FORWARD_SAFE_NSIWEBSERVICEPROXYCREATIONLISTENER(_to) \
  247.   NS_IMETHOD OnLoad(nsIWebServiceProxy *proxy) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnLoad(proxy); } \
  248.   NS_IMETHOD OnError(nsIException *error) { return !_to ? NS_ERROR_NULL_POINTER : _to->OnError(error); } 
  249.  
  250. #if 0
  251. /* Use the code below as a template for the implementation class for this interface. */
  252.  
  253. /* Header file */
  254. class nsWebServiceProxyCreationListener : public nsIWebServiceProxyCreationListener
  255. {
  256. public:
  257.   NS_DECL_ISUPPORTS
  258.   NS_DECL_NSIWEBSERVICEPROXYCREATIONLISTENER
  259.  
  260.   nsWebServiceProxyCreationListener();
  261.  
  262. private:
  263.   ~nsWebServiceProxyCreationListener();
  264.  
  265. protected:
  266.   /* additional members */
  267. };
  268.  
  269. /* Implementation file */
  270. NS_IMPL_ISUPPORTS1(nsWebServiceProxyCreationListener, nsIWebServiceProxyCreationListener)
  271.  
  272. nsWebServiceProxyCreationListener::nsWebServiceProxyCreationListener()
  273. {
  274.   /* member initializers and constructor code */
  275. }
  276.  
  277. nsWebServiceProxyCreationListener::~nsWebServiceProxyCreationListener()
  278. {
  279.   /* destructor code */
  280. }
  281.  
  282. /* void onLoad (in nsIWebServiceProxy proxy); */
  283. NS_IMETHODIMP nsWebServiceProxyCreationListener::OnLoad(nsIWebServiceProxy *proxy)
  284. {
  285.     return NS_ERROR_NOT_IMPLEMENTED;
  286. }
  287.  
  288. /* void onError (in nsIException error); */
  289. NS_IMETHODIMP nsWebServiceProxyCreationListener::OnError(nsIException *error)
  290. {
  291.     return NS_ERROR_NOT_IMPLEMENTED;
  292. }
  293.  
  294. /* End of implementation class template. */
  295. #endif
  296.  
  297.  
  298. /* starting interface:    nsIWebServiceProxy */
  299. #define NS_IWEBSERVICEPROXY_IID_STR "2122421c-1326-41db-87f8-25519d8a12cb"
  300.  
  301. #define NS_IWEBSERVICEPROXY_IID \
  302.   {0x2122421c, 0x1326, 0x41db, \
  303.     { 0x87, 0xf8, 0x25, 0x51, 0x9d, 0x8a, 0x12, 0xcb }}
  304.  
  305. class NS_NO_VTABLE nsIWebServiceProxy : public nsISupports {
  306.  public: 
  307.  
  308.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IWEBSERVICEPROXY_IID)
  309.  
  310.   /* [noscript] void Init (in nsIWSDLPort aPort, in nsIInterfaceInfo aPrimaryInterface, in nsIInterfaceInfoManager aInterfaceInfoManager, in AString aQualifier, in boolean aIsAsync); */
  311.   NS_IMETHOD Init(nsIWSDLPort *aPort, nsIInterfaceInfo *aPrimaryInterface, nsIInterfaceInfoManager *aInterfaceInfoManager, const nsAString & aQualifier, PRBool aIsAsync) = 0;
  312.  
  313.   /**
  314.    * The WSDL port that this service proxy represents.
  315.    *
  316.    * @see nsIWSDLPort
  317.    */
  318.   /* readonly attribute nsIWSDLPort port; */
  319.   NS_IMETHOD GetPort(nsIWSDLPort * *aPort) = 0;
  320.  
  321.   /**
  322.    * PR_TRUE if the service proxy methods represent an asynchronous
  323.    * calling convention. PR_FALSE if the methods are synchronous.
  324.    */
  325.   /* readonly attribute boolean isAsync; */
  326.   NS_IMETHOD GetIsAsync(PRBool *aIsAsync) = 0;
  327.  
  328.   /**
  329.    * The qualifier used for interface names related to
  330.    * this service proxy.
  331.    */
  332.   /* readonly attribute AString qualifier; */
  333.   NS_IMETHOD GetQualifier(nsAString & aQualifier) = 0;
  334.  
  335.   /**
  336.    * An enumerator that returns the set of pending calls for the
  337.    * service proxy. Each call is an instance of the 
  338.    * <code>nsIWebServiceCallContext</code> interface.
  339.    *
  340.    * @see nsIWebServiceCallContext
  341.    */
  342.   /* readonly attribute nsISimpleEnumerator pendingCalls; */
  343.   NS_IMETHOD GetPendingCalls(nsISimpleEnumerator * *aPendingCalls) = 0;
  344.  
  345.   /**
  346.    * The name of the primary interface for this proxy. This may or may not be
  347.    * the async version depending on whether or not this is an async proxy.
  348.    */
  349.   /* readonly attribute string primaryInterfaceName; */
  350.   NS_IMETHOD GetPrimaryInterfaceName(char * *aPrimaryInterfaceName) = 0;
  351.  
  352.   /**
  353.    * The name of the primary async listener interface for this proxy. 
  354.    * This will be null if this is not an async proxy.
  355.    */
  356.   /* readonly attribute string primaryAsyncListenerInterfaceName; */
  357.   NS_IMETHOD GetPrimaryAsyncListenerInterfaceName(char * *aPrimaryAsyncListenerInterfaceName) = 0;
  358.  
  359.   /**
  360.    * The collection of interfaces related to this service proxy. This
  361.    * will include the primary interface implemented by the service
  362.    * proxy as well as any listener or complex type interfaces required
  363.    * for method parameters and return values.
  364.    * NOTE: only interesting from JavaScript.
  365.    */
  366.   /* readonly attribute nsIScriptableInterfaces interfaces; */
  367.   NS_IMETHOD GetInterfaces(nsIScriptableInterfaces * *aInterfaces) = 0;
  368.  
  369. };
  370.  
  371. /* Use this macro when declaring classes that implement this interface. */
  372. #define NS_DECL_NSIWEBSERVICEPROXY \
  373.   NS_IMETHOD Init(nsIWSDLPort *aPort, nsIInterfaceInfo *aPrimaryInterface, nsIInterfaceInfoManager *aInterfaceInfoManager, const nsAString & aQualifier, PRBool aIsAsync); \
  374.   NS_IMETHOD GetPort(nsIWSDLPort * *aPort); \
  375.   NS_IMETHOD GetIsAsync(PRBool *aIsAsync); \
  376.   NS_IMETHOD GetQualifier(nsAString & aQualifier); \
  377.   NS_IMETHOD GetPendingCalls(nsISimpleEnumerator * *aPendingCalls); \
  378.   NS_IMETHOD GetPrimaryInterfaceName(char * *aPrimaryInterfaceName); \
  379.   NS_IMETHOD GetPrimaryAsyncListenerInterfaceName(char * *aPrimaryAsyncListenerInterfaceName); \
  380.   NS_IMETHOD GetInterfaces(nsIScriptableInterfaces * *aInterfaces); 
  381.  
  382. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  383. #define NS_FORWARD_NSIWEBSERVICEPROXY(_to) \
  384.   NS_IMETHOD Init(nsIWSDLPort *aPort, nsIInterfaceInfo *aPrimaryInterface, nsIInterfaceInfoManager *aInterfaceInfoManager, const nsAString & aQualifier, PRBool aIsAsync) { return _to Init(aPort, aPrimaryInterface, aInterfaceInfoManager, aQualifier, aIsAsync); } \
  385.   NS_IMETHOD GetPort(nsIWSDLPort * *aPort) { return _to GetPort(aPort); } \
  386.   NS_IMETHOD GetIsAsync(PRBool *aIsAsync) { return _to GetIsAsync(aIsAsync); } \
  387.   NS_IMETHOD GetQualifier(nsAString & aQualifier) { return _to GetQualifier(aQualifier); } \
  388.   NS_IMETHOD GetPendingCalls(nsISimpleEnumerator * *aPendingCalls) { return _to GetPendingCalls(aPendingCalls); } \
  389.   NS_IMETHOD GetPrimaryInterfaceName(char * *aPrimaryInterfaceName) { return _to GetPrimaryInterfaceName(aPrimaryInterfaceName); } \
  390.   NS_IMETHOD GetPrimaryAsyncListenerInterfaceName(char * *aPrimaryAsyncListenerInterfaceName) { return _to GetPrimaryAsyncListenerInterfaceName(aPrimaryAsyncListenerInterfaceName); } \
  391.   NS_IMETHOD GetInterfaces(nsIScriptableInterfaces * *aInterfaces) { return _to GetInterfaces(aInterfaces); } 
  392.  
  393. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  394. #define NS_FORWARD_SAFE_NSIWEBSERVICEPROXY(_to) \
  395.   NS_IMETHOD Init(nsIWSDLPort *aPort, nsIInterfaceInfo *aPrimaryInterface, nsIInterfaceInfoManager *aInterfaceInfoManager, const nsAString & aQualifier, PRBool aIsAsync) { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(aPort, aPrimaryInterface, aInterfaceInfoManager, aQualifier, aIsAsync); } \
  396.   NS_IMETHOD GetPort(nsIWSDLPort * *aPort) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPort(aPort); } \
  397.   NS_IMETHOD GetIsAsync(PRBool *aIsAsync) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetIsAsync(aIsAsync); } \
  398.   NS_IMETHOD GetQualifier(nsAString & aQualifier) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetQualifier(aQualifier); } \
  399.   NS_IMETHOD GetPendingCalls(nsISimpleEnumerator * *aPendingCalls) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPendingCalls(aPendingCalls); } \
  400.   NS_IMETHOD GetPrimaryInterfaceName(char * *aPrimaryInterfaceName) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPrimaryInterfaceName(aPrimaryInterfaceName); } \
  401.   NS_IMETHOD GetPrimaryAsyncListenerInterfaceName(char * *aPrimaryAsyncListenerInterfaceName) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPrimaryAsyncListenerInterfaceName(aPrimaryAsyncListenerInterfaceName); } \
  402.   NS_IMETHOD GetInterfaces(nsIScriptableInterfaces * *aInterfaces) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetInterfaces(aInterfaces); } 
  403.  
  404. #if 0
  405. /* Use the code below as a template for the implementation class for this interface. */
  406.  
  407. /* Header file */
  408. class nsWebServiceProxy : public nsIWebServiceProxy
  409. {
  410. public:
  411.   NS_DECL_ISUPPORTS
  412.   NS_DECL_NSIWEBSERVICEPROXY
  413.  
  414.   nsWebServiceProxy();
  415.  
  416. private:
  417.   ~nsWebServiceProxy();
  418.  
  419. protected:
  420.   /* additional members */
  421. };
  422.  
  423. /* Implementation file */
  424. NS_IMPL_ISUPPORTS1(nsWebServiceProxy, nsIWebServiceProxy)
  425.  
  426. nsWebServiceProxy::nsWebServiceProxy()
  427. {
  428.   /* member initializers and constructor code */
  429. }
  430.  
  431. nsWebServiceProxy::~nsWebServiceProxy()
  432. {
  433.   /* destructor code */
  434. }
  435.  
  436. /* [noscript] void Init (in nsIWSDLPort aPort, in nsIInterfaceInfo aPrimaryInterface, in nsIInterfaceInfoManager aInterfaceInfoManager, in AString aQualifier, in boolean aIsAsync); */
  437. NS_IMETHODIMP nsWebServiceProxy::Init(nsIWSDLPort *aPort, nsIInterfaceInfo *aPrimaryInterface, nsIInterfaceInfoManager *aInterfaceInfoManager, const nsAString & aQualifier, PRBool aIsAsync)
  438. {
  439.     return NS_ERROR_NOT_IMPLEMENTED;
  440. }
  441.  
  442. /* readonly attribute nsIWSDLPort port; */
  443. NS_IMETHODIMP nsWebServiceProxy::GetPort(nsIWSDLPort * *aPort)
  444. {
  445.     return NS_ERROR_NOT_IMPLEMENTED;
  446. }
  447.  
  448. /* readonly attribute boolean isAsync; */
  449. NS_IMETHODIMP nsWebServiceProxy::GetIsAsync(PRBool *aIsAsync)
  450. {
  451.     return NS_ERROR_NOT_IMPLEMENTED;
  452. }
  453.  
  454. /* readonly attribute AString qualifier; */
  455. NS_IMETHODIMP nsWebServiceProxy::GetQualifier(nsAString & aQualifier)
  456. {
  457.     return NS_ERROR_NOT_IMPLEMENTED;
  458. }
  459.  
  460. /* readonly attribute nsISimpleEnumerator pendingCalls; */
  461. NS_IMETHODIMP nsWebServiceProxy::GetPendingCalls(nsISimpleEnumerator * *aPendingCalls)
  462. {
  463.     return NS_ERROR_NOT_IMPLEMENTED;
  464. }
  465.  
  466. /* readonly attribute string primaryInterfaceName; */
  467. NS_IMETHODIMP nsWebServiceProxy::GetPrimaryInterfaceName(char * *aPrimaryInterfaceName)
  468. {
  469.     return NS_ERROR_NOT_IMPLEMENTED;
  470. }
  471.  
  472. /* readonly attribute string primaryAsyncListenerInterfaceName; */
  473. NS_IMETHODIMP nsWebServiceProxy::GetPrimaryAsyncListenerInterfaceName(char * *aPrimaryAsyncListenerInterfaceName)
  474. {
  475.     return NS_ERROR_NOT_IMPLEMENTED;
  476. }
  477.  
  478. /* readonly attribute nsIScriptableInterfaces interfaces; */
  479. NS_IMETHODIMP nsWebServiceProxy::GetInterfaces(nsIScriptableInterfaces * *aInterfaces)
  480. {
  481.     return NS_ERROR_NOT_IMPLEMENTED;
  482. }
  483.  
  484. /* End of implementation class template. */
  485. #endif
  486.  
  487.  
  488. /* starting interface:    nsIWebServiceCallContext */
  489. #define NS_IWEBSERVICECALLCONTEXT_IID_STR "87d87900-f102-4a15-b345-7b77a49d2df2"
  490.  
  491. #define NS_IWEBSERVICECALLCONTEXT_IID \
  492.   {0x87d87900, 0xf102, 0x4a15, \
  493.     { 0xb3, 0x45, 0x7b, 0x77, 0xa4, 0x9d, 0x2d, 0xf2 }}
  494.  
  495. /**
  496.  * A representation of a method invocation on a web service.
  497.  * An instance of this interface is returned as a result of making
  498.  * an asynchronous call and can be queried for status of the
  499.  * call.
  500.  */
  501. class NS_NO_VTABLE nsIWebServiceCallContext : public nsISupports {
  502.  public: 
  503.  
  504.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IWEBSERVICECALLCONTEXT_IID)
  505.  
  506.   /** 
  507.    * Possible values of the <code>status</code> attribute. A pending
  508.    * call has a status of PENDING. A completed call has a status of
  509.    * SUCCEEDED or FAILED depending on the result of the call.
  510.    */
  511.   enum { PENDING = 0U };
  512.  
  513.   enum { SUCCEEDED = 1U };
  514.  
  515.   enum { FAILED = 2U };
  516.  
  517.   enum { ABORTED = 3U };
  518.  
  519.   /**
  520.    * The proxy object on which the call was made.
  521.    * 
  522.    * @see nsIWebServiceProxy
  523.    */
  524.   /* readonly attribute nsIWebServiceProxy proxy; */
  525.   NS_IMETHOD GetProxy(nsIWebServiceProxy * *aProxy) = 0;
  526.  
  527.   /**
  528.    * The name of the method that was invoked.
  529.    */
  530.   /* readonly attribute AString methodName; */
  531.   NS_IMETHOD GetMethodName(nsAString & aMethodName) = 0;
  532.  
  533.   /**
  534.    * The status of the call, whether pending, completed successfully
  535.    * or completed with a fault.
  536.    */
  537.   /* readonly attribute PRUint32 status; */
  538.   NS_IMETHOD GetStatus(PRUint32 *aStatus) = 0;
  539.  
  540.   /**
  541.    * The exception generated by the call if the status is FAILURE.
  542.    * The exception object can be introspected for more information.
  543.    * The <code>data</code> member can be QIed to a 
  544.    * <code>nsISOAPFault</code> instance for calls that use a
  545.    * SOAP binding.
  546.    */
  547.   /* readonly attribute nsIException pendingException; */
  548.   NS_IMETHOD GetPendingException(nsIException * *aPendingException) = 0;
  549.  
  550.   /**
  551.    * The WSDL operation that correpsonds to the method being invoked.
  552.    *
  553.    * @see nsIWSDLOperation
  554.    */
  555.   /* readonly attribute nsIWSDLOperation operation; */
  556.   NS_IMETHOD GetOperation(nsIWSDLOperation * *aOperation) = 0;
  557.  
  558.   /**
  559.    * Called to abort a pending call. If the call is still pending,
  560.    * its callback instance's <code>onError</code> will be invoked,
  561.    * passing in the specified exception.
  562.    *
  563.    * @param error The exception passed to the callback instance's
  564.    *              <code>onError</code> method.
  565.    */
  566.   /* void abort (in nsIException error); */
  567.   NS_IMETHOD Abort(nsIException *error) = 0;
  568.  
  569. };
  570.  
  571. /* Use this macro when declaring classes that implement this interface. */
  572. #define NS_DECL_NSIWEBSERVICECALLCONTEXT \
  573.   NS_IMETHOD GetProxy(nsIWebServiceProxy * *aProxy); \
  574.   NS_IMETHOD GetMethodName(nsAString & aMethodName); \
  575.   NS_IMETHOD GetStatus(PRUint32 *aStatus); \
  576.   NS_IMETHOD GetPendingException(nsIException * *aPendingException); \
  577.   NS_IMETHOD GetOperation(nsIWSDLOperation * *aOperation); \
  578.   NS_IMETHOD Abort(nsIException *error); 
  579.  
  580. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  581. #define NS_FORWARD_NSIWEBSERVICECALLCONTEXT(_to) \
  582.   NS_IMETHOD GetProxy(nsIWebServiceProxy * *aProxy) { return _to GetProxy(aProxy); } \
  583.   NS_IMETHOD GetMethodName(nsAString & aMethodName) { return _to GetMethodName(aMethodName); } \
  584.   NS_IMETHOD GetStatus(PRUint32 *aStatus) { return _to GetStatus(aStatus); } \
  585.   NS_IMETHOD GetPendingException(nsIException * *aPendingException) { return _to GetPendingException(aPendingException); } \
  586.   NS_IMETHOD GetOperation(nsIWSDLOperation * *aOperation) { return _to GetOperation(aOperation); } \
  587.   NS_IMETHOD Abort(nsIException *error) { return _to Abort(error); } 
  588.  
  589. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  590. #define NS_FORWARD_SAFE_NSIWEBSERVICECALLCONTEXT(_to) \
  591.   NS_IMETHOD GetProxy(nsIWebServiceProxy * *aProxy) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetProxy(aProxy); } \
  592.   NS_IMETHOD GetMethodName(nsAString & aMethodName) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetMethodName(aMethodName); } \
  593.   NS_IMETHOD GetStatus(PRUint32 *aStatus) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStatus(aStatus); } \
  594.   NS_IMETHOD GetPendingException(nsIException * *aPendingException) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPendingException(aPendingException); } \
  595.   NS_IMETHOD GetOperation(nsIWSDLOperation * *aOperation) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetOperation(aOperation); } \
  596.   NS_IMETHOD Abort(nsIException *error) { return !_to ? NS_ERROR_NULL_POINTER : _to->Abort(error); } 
  597.  
  598. #if 0
  599. /* Use the code below as a template for the implementation class for this interface. */
  600.  
  601. /* Header file */
  602. class nsWebServiceCallContext : public nsIWebServiceCallContext
  603. {
  604. public:
  605.   NS_DECL_ISUPPORTS
  606.   NS_DECL_NSIWEBSERVICECALLCONTEXT
  607.  
  608.   nsWebServiceCallContext();
  609.  
  610. private:
  611.   ~nsWebServiceCallContext();
  612.  
  613. protected:
  614.   /* additional members */
  615. };
  616.  
  617. /* Implementation file */
  618. NS_IMPL_ISUPPORTS1(nsWebServiceCallContext, nsIWebServiceCallContext)
  619.  
  620. nsWebServiceCallContext::nsWebServiceCallContext()
  621. {
  622.   /* member initializers and constructor code */
  623. }
  624.  
  625. nsWebServiceCallContext::~nsWebServiceCallContext()
  626. {
  627.   /* destructor code */
  628. }
  629.  
  630. /* readonly attribute nsIWebServiceProxy proxy; */
  631. NS_IMETHODIMP nsWebServiceCallContext::GetProxy(nsIWebServiceProxy * *aProxy)
  632. {
  633.     return NS_ERROR_NOT_IMPLEMENTED;
  634. }
  635.  
  636. /* readonly attribute AString methodName; */
  637. NS_IMETHODIMP nsWebServiceCallContext::GetMethodName(nsAString & aMethodName)
  638. {
  639.     return NS_ERROR_NOT_IMPLEMENTED;
  640. }
  641.  
  642. /* readonly attribute PRUint32 status; */
  643. NS_IMETHODIMP nsWebServiceCallContext::GetStatus(PRUint32 *aStatus)
  644. {
  645.     return NS_ERROR_NOT_IMPLEMENTED;
  646. }
  647.  
  648. /* readonly attribute nsIException pendingException; */
  649. NS_IMETHODIMP nsWebServiceCallContext::GetPendingException(nsIException * *aPendingException)
  650. {
  651.     return NS_ERROR_NOT_IMPLEMENTED;
  652. }
  653.  
  654. /* readonly attribute nsIWSDLOperation operation; */
  655. NS_IMETHODIMP nsWebServiceCallContext::GetOperation(nsIWSDLOperation * *aOperation)
  656. {
  657.     return NS_ERROR_NOT_IMPLEMENTED;
  658. }
  659.  
  660. /* void abort (in nsIException error); */
  661. NS_IMETHODIMP nsWebServiceCallContext::Abort(nsIException *error)
  662. {
  663.     return NS_ERROR_NOT_IMPLEMENTED;
  664. }
  665.  
  666. /* End of implementation class template. */
  667. #endif
  668.  
  669.  
  670. /* starting interface:    nsIWebServiceSOAPCallContext */
  671. #define NS_IWEBSERVICESOAPCALLCONTEXT_IID_STR "1ef83ece-b645-4b55-a501-df42c3333b47"
  672.  
  673. #define NS_IWEBSERVICESOAPCALLCONTEXT_IID \
  674.   {0x1ef83ece, 0xb645, 0x4b55, \
  675.     { 0xa5, 0x01, 0xdf, 0x42, 0xc3, 0x33, 0x3b, 0x47 }}
  676.  
  677. class NS_NO_VTABLE nsIWebServiceSOAPCallContext : public nsIWebServiceCallContext {
  678.  public: 
  679.  
  680.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IWEBSERVICESOAPCALLCONTEXT_IID)
  681.  
  682.   /**
  683.    * For users who want access to the lower-level constructs that
  684.    * are used for the method invocation, this attributes provides
  685.    * the SOAP response once the call has completed.
  686.    *
  687.    * @see nsISOAPResponse
  688.    */
  689.   /* readonly attribute nsISOAPResponse soapResponse; */
  690.   NS_IMETHOD GetSoapResponse(nsISOAPResponse * *aSoapResponse) = 0;
  691.  
  692. };
  693.  
  694. /* Use this macro when declaring classes that implement this interface. */
  695. #define NS_DECL_NSIWEBSERVICESOAPCALLCONTEXT \
  696.   NS_IMETHOD GetSoapResponse(nsISOAPResponse * *aSoapResponse); 
  697.  
  698. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  699. #define NS_FORWARD_NSIWEBSERVICESOAPCALLCONTEXT(_to) \
  700.   NS_IMETHOD GetSoapResponse(nsISOAPResponse * *aSoapResponse) { return _to GetSoapResponse(aSoapResponse); } 
  701.  
  702. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  703. #define NS_FORWARD_SAFE_NSIWEBSERVICESOAPCALLCONTEXT(_to) \
  704.   NS_IMETHOD GetSoapResponse(nsISOAPResponse * *aSoapResponse) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSoapResponse(aSoapResponse); } 
  705.  
  706. #if 0
  707. /* Use the code below as a template for the implementation class for this interface. */
  708.  
  709. /* Header file */
  710. class nsWebServiceSOAPCallContext : public nsIWebServiceSOAPCallContext
  711. {
  712. public:
  713.   NS_DECL_ISUPPORTS
  714.   NS_DECL_NSIWEBSERVICESOAPCALLCONTEXT
  715.  
  716.   nsWebServiceSOAPCallContext();
  717.  
  718. private:
  719.   ~nsWebServiceSOAPCallContext();
  720.  
  721. protected:
  722.   /* additional members */
  723. };
  724.  
  725. /* Implementation file */
  726. NS_IMPL_ISUPPORTS1(nsWebServiceSOAPCallContext, nsIWebServiceSOAPCallContext)
  727.  
  728. nsWebServiceSOAPCallContext::nsWebServiceSOAPCallContext()
  729. {
  730.   /* member initializers and constructor code */
  731. }
  732.  
  733. nsWebServiceSOAPCallContext::~nsWebServiceSOAPCallContext()
  734. {
  735.   /* destructor code */
  736. }
  737.  
  738. /* readonly attribute nsISOAPResponse soapResponse; */
  739. NS_IMETHODIMP nsWebServiceSOAPCallContext::GetSoapResponse(nsISOAPResponse * *aSoapResponse)
  740. {
  741.     return NS_ERROR_NOT_IMPLEMENTED;
  742. }
  743.  
  744. /* End of implementation class template. */
  745. #endif
  746.  
  747.  
  748. /* starting interface:    nsIWebServiceComplexTypeWrapper */
  749. #define NS_IWEBSERVICECOMPLEXTYPEWRAPPER_IID_STR "b16b15bc-bfad-43cf-b374-2e4651acbc3c"
  750.  
  751. #define NS_IWEBSERVICECOMPLEXTYPEWRAPPER_IID \
  752.   {0xb16b15bc, 0xbfad, 0x43cf, \
  753.     { 0xb3, 0x74, 0x2e, 0x46, 0x51, 0xac, 0xbc, 0x3c }}
  754.  
  755. class NS_NO_VTABLE nsIWebServiceComplexTypeWrapper : public nsISupports {
  756.  public: 
  757.  
  758.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IWEBSERVICECOMPLEXTYPEWRAPPER_IID)
  759.  
  760.   /* void Init (in nsISupports aComplexTypeInstance, in nsIInterfaceInfo aInterfaceInfo); */
  761.   NS_IMETHOD Init(nsISupports *aComplexTypeInstance, nsIInterfaceInfo *aInterfaceInfo) = 0;
  762.  
  763. };
  764.  
  765. /* Use this macro when declaring classes that implement this interface. */
  766. #define NS_DECL_NSIWEBSERVICECOMPLEXTYPEWRAPPER \
  767.   NS_IMETHOD Init(nsISupports *aComplexTypeInstance, nsIInterfaceInfo *aInterfaceInfo); 
  768.  
  769. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  770. #define NS_FORWARD_NSIWEBSERVICECOMPLEXTYPEWRAPPER(_to) \
  771.   NS_IMETHOD Init(nsISupports *aComplexTypeInstance, nsIInterfaceInfo *aInterfaceInfo) { return _to Init(aComplexTypeInstance, aInterfaceInfo); } 
  772.  
  773. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  774. #define NS_FORWARD_SAFE_NSIWEBSERVICECOMPLEXTYPEWRAPPER(_to) \
  775.   NS_IMETHOD Init(nsISupports *aComplexTypeInstance, nsIInterfaceInfo *aInterfaceInfo) { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(aComplexTypeInstance, aInterfaceInfo); } 
  776.  
  777. #if 0
  778. /* Use the code below as a template for the implementation class for this interface. */
  779.  
  780. /* Header file */
  781. class nsWebServiceComplexTypeWrapper : public nsIWebServiceComplexTypeWrapper
  782. {
  783. public:
  784.   NS_DECL_ISUPPORTS
  785.   NS_DECL_NSIWEBSERVICECOMPLEXTYPEWRAPPER
  786.  
  787.   nsWebServiceComplexTypeWrapper();
  788.  
  789. private:
  790.   ~nsWebServiceComplexTypeWrapper();
  791.  
  792. protected:
  793.   /* additional members */
  794. };
  795.  
  796. /* Implementation file */
  797. NS_IMPL_ISUPPORTS1(nsWebServiceComplexTypeWrapper, nsIWebServiceComplexTypeWrapper)
  798.  
  799. nsWebServiceComplexTypeWrapper::nsWebServiceComplexTypeWrapper()
  800. {
  801.   /* member initializers and constructor code */
  802. }
  803.  
  804. nsWebServiceComplexTypeWrapper::~nsWebServiceComplexTypeWrapper()
  805. {
  806.   /* destructor code */
  807. }
  808.  
  809. /* void Init (in nsISupports aComplexTypeInstance, in nsIInterfaceInfo aInterfaceInfo); */
  810. NS_IMETHODIMP nsWebServiceComplexTypeWrapper::Init(nsISupports *aComplexTypeInstance, nsIInterfaceInfo *aInterfaceInfo)
  811. {
  812.     return NS_ERROR_NOT_IMPLEMENTED;
  813. }
  814.  
  815. /* End of implementation class template. */
  816. #endif
  817.  
  818.  
  819. /* starting interface:    nsIWebServicePropertyBagWrapper */
  820. #define NS_IWEBSERVICEPROPERTYBAGWRAPPER_IID_STR "e0b1765e-c0be-4a28-aca3-b292c5c3788b"
  821.  
  822. #define NS_IWEBSERVICEPROPERTYBAGWRAPPER_IID \
  823.   {0xe0b1765e, 0xc0be, 0x4a28, \
  824.     { 0xac, 0xa3, 0xb2, 0x92, 0xc5, 0xc3, 0x78, 0x8b }}
  825.  
  826. class NS_NO_VTABLE nsIWebServicePropertyBagWrapper : public nsISupports {
  827.  public: 
  828.  
  829.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IWEBSERVICEPROPERTYBAGWRAPPER_IID)
  830.  
  831.   /* void Init (in nsIPropertyBag aPropertyBag, in nsIInterfaceInfo aInterfaceInfo); */
  832.   NS_IMETHOD Init(nsIPropertyBag *aPropertyBag, nsIInterfaceInfo *aInterfaceInfo) = 0;
  833.  
  834. };
  835.  
  836. /* Use this macro when declaring classes that implement this interface. */
  837. #define NS_DECL_NSIWEBSERVICEPROPERTYBAGWRAPPER \
  838.   NS_IMETHOD Init(nsIPropertyBag *aPropertyBag, nsIInterfaceInfo *aInterfaceInfo); 
  839.  
  840. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  841. #define NS_FORWARD_NSIWEBSERVICEPROPERTYBAGWRAPPER(_to) \
  842.   NS_IMETHOD Init(nsIPropertyBag *aPropertyBag, nsIInterfaceInfo *aInterfaceInfo) { return _to Init(aPropertyBag, aInterfaceInfo); } 
  843.  
  844. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  845. #define NS_FORWARD_SAFE_NSIWEBSERVICEPROPERTYBAGWRAPPER(_to) \
  846.   NS_IMETHOD Init(nsIPropertyBag *aPropertyBag, nsIInterfaceInfo *aInterfaceInfo) { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(aPropertyBag, aInterfaceInfo); } 
  847.  
  848. #if 0
  849. /* Use the code below as a template for the implementation class for this interface. */
  850.  
  851. /* Header file */
  852. class nsWebServicePropertyBagWrapper : public nsIWebServicePropertyBagWrapper
  853. {
  854. public:
  855.   NS_DECL_ISUPPORTS
  856.   NS_DECL_NSIWEBSERVICEPROPERTYBAGWRAPPER
  857.  
  858.   nsWebServicePropertyBagWrapper();
  859.  
  860. private:
  861.   ~nsWebServicePropertyBagWrapper();
  862.  
  863. protected:
  864.   /* additional members */
  865. };
  866.  
  867. /* Implementation file */
  868. NS_IMPL_ISUPPORTS1(nsWebServicePropertyBagWrapper, nsIWebServicePropertyBagWrapper)
  869.  
  870. nsWebServicePropertyBagWrapper::nsWebServicePropertyBagWrapper()
  871. {
  872.   /* member initializers and constructor code */
  873. }
  874.  
  875. nsWebServicePropertyBagWrapper::~nsWebServicePropertyBagWrapper()
  876. {
  877.   /* destructor code */
  878. }
  879.  
  880. /* void Init (in nsIPropertyBag aPropertyBag, in nsIInterfaceInfo aInterfaceInfo); */
  881. NS_IMETHODIMP nsWebServicePropertyBagWrapper::Init(nsIPropertyBag *aPropertyBag, nsIInterfaceInfo *aInterfaceInfo)
  882. {
  883.     return NS_ERROR_NOT_IMPLEMENTED;
  884. }
  885.  
  886. /* End of implementation class template. */
  887. #endif
  888.  
  889. #define NS_WEBSERVICEPROXYFACTORY_CLASSID           \
  890. { /* 4E557E69-CCE0-47da-A7D3-2A7ED666F566 */        \
  891.  0x4e557e69, 0xcce0, 0x47da,                        \
  892.  {0xa7, 0xd3, 0x2a, 0x7e, 0xd6, 0x66, 0xf5, 0x66}}
  893. #define NS_WEBSERVICEPROXYFACTORY_CONTRACTID "@mozilla.org/xmlextras/proxy/webserviceproxyfactory;1"
  894. #define NS_WEBSERVICEPROXY_CLASSID                  \
  895. { /* 1220efd4-8018-45b0-bfc1-0c0716ee0bfb */        \
  896.  0x1220efd4, 0x8018, 0x45b0,                        \
  897.  {0xbf, 0xc1, 0x0c, 0x07, 0x16, 0xee, 0x0b, 0xfb}}
  898. #define NS_WEBSERVICEPROXY_CONTRACTID "@mozilla.org/xmlextras/proxy/webserviceproxy;1"
  899. #define NS_WEBSERVICECOMPLEXTYPEWRAPPER_CLASSID     \
  900. { /* 615272eb-3908-4fcc-b8f6-94d5a146e2bc */        \
  901.  0x615272eb, 0x3908, 0x4fcc,                        \
  902.  {0xb8, 0xf6, 0x94, 0xd5, 0xa1, 0x46, 0xe2, 0xbc}}
  903. #define NS_WEBSERVICECOMPLEXTYPEWRAPPER_CONTRACTID "@mozilla.org/xmlextras/proxy/webservicecomplextypewrapper;1"
  904. #define NS_WEBSERVICEPROPERTYBAGWRAPPER_CLASSID     \
  905. { /* 1c76aea3-0810-45b7-bce9-03abc209eb8c */        \
  906.  0x1c76aea3, 0x0810, 0x45b7,                        \
  907.  {0xbc, 0xe9, 0x03, 0xab, 0xc2, 0x09, 0xeb, 0x8c}} 
  908. #define NS_WEBSERVICEPROPERTYBAGWRAPPER_CONTRACTID "@mozilla.org/xmlextras/proxy/webservicepropertybagwrapper;1"
  909.  
  910. #endif /* __gen_nsIWebServiceProxy_h__ */
  911.